Usenet 1993 July

home *** CD-ROM | disk | FTP | other *** search

/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume25 / zip / part06 < prev next >

Wrap

Text File | 1992-03-01 | 46.4 KB | 1,708 lines

Newsgroups: comp.sources.unix From: madler@cco.caltech.edu (Mark Adler) Subject: v25i147: zip - file compression/archive tool, Part06/07 Sender: unix-sources-moderator@pa.dec.com Approved: vixie@pa.dec.com Submitted-By: madler@cco.caltech.edu (Mark Adler) Posting-Number: Volume 25, Issue 147 Archive-Name: zip/part06 #! /bin/sh # This is a shell archive. Remove anything before this line, then unpack # it by saving it into a file and typing "sh file". To overwrite existing # files, type "sh file -c". You can also feed this as standard input via # unshar, or by typing "sh <file", e.g.. If this archive is complete, you # will see the following message at the end: # "End of archive 6 (of 7)." # Contents: fileio.c # Wrapped by vixie@cognition.pa.dec.com on Sun Mar 1 18:57:39 1992 PATH=/bin:/usr/bin:/usr/ucb ; export PATH if test -f 'fileio.c' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'fileio.c'\" else echo shar: Extracting \"'fileio.c'\" $44358 characters$ sed "s/^X//" >'fileio.c' <<'END_OF_FILE' X/* X X Copyright (C) 1990,1991 Mark Adler, Richard B. Wales, and Jean-loup Gailly. X Permission is granted to any individual or institution to use, copy, or X redistribute this software so long as all of the original files are included X unmodified, that it is not sold for profit, and that this copyright notice X is retained. X X*/ X X/* X * fileio.c by Mark Adler. X */ X X#include "zip.h" X X#include <time.h> X#include <errno.h> X X#ifdef S_IWUSR /* For MINIX */ X# ifdef S_IWRITE X# undef S_IWRITE X# endif /* S_IWRITE */ X# define S_IWRITE S_IWUSR X#endif /* S_IWUSR */ X X#ifdef MSDOS X# include <io.h> X# ifdef __TURBOC__ X# include <dir.h> X# else /* !__TURBOC__ */ X# include <direct.h> X# endif /* ?__TURBOC__ */ X# define link rename X# ifdef OS2 X# define MATCH shmatch X# else /* !OS2 */ X# define MATCH dosmatch X# endif /* ?OS2 */ X#else /* !MSDOS */ X extern int errno; /* error number from system functions */ X# ifdef VMS X# define RMDIR X# define link rename X# endif /* VMS */ X# define MATCH shmatch X#endif /* ?MSDOS */ X X#ifdef UTS X# define RMDIR X#endif /* UTS */ X X X/* Extra malloc() space in names for cutpath() */ X#ifdef VMS X# define PAD 3 /* may have to change .FOO] to ]FOO.DIR */ X#else /* !VMS */ X# define PAD 0 X#endif /* ?VMS */ X X X/* For now, assume DIRENT implies System V implies TERMIO */ X#ifdef DIRENT X# ifndef MINIX X# ifndef TERMIO X# define TERMIO X# endif /* !TERMIO */ X# endif /* !MINIX */ X#endif /* DIRENT */ X X X#ifndef EXPORT X# ifdef MSVMS X# ifdef MSDOS X# include <conio.h> X# else /* !MSDOS */ X# define getch() getc(stderr) X# endif /* ?MSDOS */ X# else /* !MSVMS */ X# ifdef TERMIO /* Amdahl, Cray, all SysV? */ X# ifdef CONVEX X# include <sys/termios.h> X# include <sgtty.h> X# else /* !CONVEX */ X# include <sys/termio.h> X# define sgttyb termio X# define sg_flags c_lflag X# endif /* ?CONVEX */ X int ioctl OF((int, int, voidp *)); X# define GTTY(f,s) ioctl(f,TCGETA,s) X# define STTY(f,s) ioctl(f,TCSETAW,s) X# else /* !TERMIO */ X# ifndef MINIX X# include <sys/ioctl.h> X# endif /* !MINIX */ X# include <sgtty.h> X int gtty OF((int, struct sgttyb *)); X int stty OF((int, struct sgttyb *)); X# define GTTY gtty X# define STTY stty X# endif /* ?TERMIO */ X int isatty OF((int)); X char *ttyname OF((int)); X int open OF((char *, int, ...)); X int close OF((int)); X int read OF((int, voidp *, int)); X# endif /* ?MSVMS */ X#endif /* !EXPORT */ X X X X/* For directory access */ X#ifndef UTIL X#ifdef DIRENT /* use getdents() */ X# ifdef MINIX X# include <dirent.h> X# else /* !MINIX */ X# include <sys/dirent.h> X# endif /* ?MINIX */ X# define direct dirent X# ifdef MINIX X int getdents OF((int, char *, unsigned)); X# else /* !MINIX */ X int getdents OF((int, char *, int)); X# endif /* ?MINIX */ X# define DBSZ 4096 /* This has to be bigger than a directory block */ X typedef struct { /* directory stream buffer */ X int f; /* file descriptor for the directory "file" */ X char *p; /* pointer to next entry in buffer */ X char *q; /* pointer after end of buffer contents */ X char b[DBSZ]; /* buffer */ X } dstrm; X#else /* !DIRENT */ /* use opendir(), etc. */ X# ifdef CONVEX X# include <dirent.h> X# define direct dirent X# endif /* CONVEX */ X# ifdef NDIR X# include "ndir.h" /* for HPUX */ X# else /* !NDIR */ X# ifdef MSDOS X# ifdef OS2 X# include "dir_os2.h" X# else /* !OS2 */ X# include <dos.h> X# ifdef __TURBOC__ X# define FATTR FA_HIDDEN+FA_SYSTEM+FA_DIREC X# define FFIRST(n,d) findfirst(n,(struct ffblk *)d,FATTR) X# define FNEXT(d) findnext((struct ffblk *)d) X# else /* !__TURBOC__ */ X# define FATTR _A_HIDDEN+_A_SYSTEM+_A_SUBDIR X# define FFIRST(n,d) _dos_findfirst(n,FATTR,(struct find_t *)d) X# define FNEXT(d) _dos_findnext((struct find_t *)d) X# endif /* ?__TURBOC__ */ X typedef struct direct { X char d_reserved[30]; X char d_name[13]; X int d_first; X } DIR; X# endif /* ?OS2 */ X# else /* !MSDOS */ X# ifdef VMS X# include <rms.h> X# include <ssdef.h> X# include <descrip.h> X typedef struct direct { X int d_wild; /* flag for wildcard vs. non-wild */ X struct FAB fab; X struct NAM nam; X char d_qualwildname[NAM$C_MAXRSS + 1]; X char d_name[NAM$C_MAXRSS + 1]; X } DIR; X# else /* !VMS */ X# include <sys/dir.h> X# ifdef NODIR /* for AT&T 3B1 */ X# define dirent direct X typedef FILE DIR; X# define dstrm DIR X# endif /* NODIR */ X# endif /* ?VMS */ X# endif /* ?MSDOS */ X# endif /* ?NDIR */ X# define dstrm DIR X# ifndef NODIR X DIR *opendir OF((char *)); X# endif /* !NODIR */ X# ifndef CONVEX X struct direct *readdir OF((DIR *)); X# endif /* !CONVEX */ X#endif /* ?DIRENT */ X#endif /* !UTIL */ X X X/* Library functions not in (most) header files */ char *mktemp OF((char *)); int link OF((char *, char *)); int unlink OF((char *)); X#ifndef CONVEX X# ifndef AIX X int chmod OF((char *, int)); X# endif /* !AIX */ X#endif /* !CONVEX */ X X X#ifndef UTIL /* the companion #endif is a bit of ways down ... */ X X#ifndef __TURBOC__ X int utime OF((char *, time_t *)); X#endif /* !__TURBOC__ */ X#ifndef MSDOS X int open OF((char *, int, ...)); X int close OF((int)); X# ifndef RMDIR X int rmdir OF((char *)); X# endif /* !RMDIR */ X#endif /* !MSDOS */ X X X/* Local globals (kinda like "military intelligence" or "broadcast quality") */ local int exflag = 0; /* Exclude flag */ X X/* Local functions */ X#ifdef PROTO X# ifdef VMS X local void vms_wild(char *, dstrm *); X# endif /* VMS */ X# ifdef DIRENT X local dstrm *opend(char *); X local void closed(dstrm *); X# endif /* DIRENT */ X local char *readd(dstrm *); X local int fqcmp(voidp *, voidp *); X local int fqcmpz(voidp *, voidp *); X local char *last(char *); X local char *msname(char *); X# ifdef VMS X local char *strlower(char *); X local char *strupper(char *); X# endif /* VMS */ X local char *ex2in(char *); X local int newname(char *); X local void inctime(struct tm *); X local ulg unix2dostime(time_t *); X# ifndef __TURBOC__ X local int cmptime(struct tm *, struct tm *); X local time_t invlocal(struct tm *); X# endif /* !__TURBOC__ */ X#endif /* PROTO */ X X X X#ifndef OS2 X#ifdef MSDOS dstrm *opendir(n) char *n; /* directory to open */ X/* Start searching for files in the MSDOS directory n */ X{ X dstrm *d; /* malloc'd return value */ X char *p; /* malloc'd temporary string */ X X if ((d = (dstrm *)malloc(sizeof(dstrm))) == NULL || X (p = malloc(strlen(n) + 5)) == NULL) X return NULL; X strcat(strcpy(p, n), "/*.*"); X if (FFIRST(p, d)) X { X free((voidp *)p); X return NULL; X } X free((voidp *)p); X d->d_first = 1; X return d; X} X struct direct *readdir(d) dstrm *d; /* directory stream to read from */ X/* Return pointer to first or next directory entry, or NULL if end. */ X{ X if (d->d_first) X d->d_first = 0; X else X if (FNEXT(d)) X return NULL; X return (struct direct *)d; X} X# define closedir free X#endif /* MSDOS */ X#endif /* !OS2 */ X X X#ifdef VMS X/*--------------------------------------------------------------------------- X X _vms_findfirst() and _vms_findnext(), based on public-domain DECUS C X fwild() and fnext() routines (originally written by Martin Minow, poss- X ibly modified by Jerry Leichter for bintnxvms.c), were written by Greg X Roelofs and are still in the public domain. Routines approximate the X behavior of MS-DOS (MSC and Turbo C) findfirst and findnext functions. X X ---------------------------------------------------------------------------*/ local void vms_wild(p, d) char *p; dstrm *d; X{ X /* X * Do wildcard setup X */ X /* set up the FAB and NAM blocks. */ X d->fab = cc$rms_fab; /* initialize fab */ X d->nam = cc$rms_nam; /* initialize nam */ X X d->fab.fab$l_nam = &d->nam; /* fab -> nam */ X d->fab.fab$l_fna = p; /* argument wild name */ X d->fab.fab$b_fns = strlen(p); /* length */ X X d->nam.nam$l_esa = d->d_qualwildname; /* qualified wild name */ X d->nam.nam$b_ess = NAM$C_MAXRSS; /* max length */ X d->nam.nam$l_rsa = d->d_name; /* matching file name */ X d->nam.nam$b_rss = NAM$C_MAXRSS; /* max length */ X X /* parse the file name */ X if (sys$parse(&d->fab) != RMS$_NORMAL) X return -1; X /* Does this replace d->fab.fab$l_fna with a new string in its own space? X I sure hope so, since p is free'ed before this routine returns. */ X X /* have qualified wild name (i.e., disk:[dir.subdir]*.*); null-terminate X * and set wild-flag */ X d->d_qualwildname[d->nam.nam$b_esl] = '\0'; X d->d_wild = (d->nam.nam$l_fnb & NAM$M_WILDCARD)? 1 : 0; /* not used... */ X#ifdef DEBUG X printf(" incoming wildname: %s\n", p); X printf(" qualified wildname: %s\n", d->d_qualwildname); X#endif /* DEBUG */ X} X dstrm *opendir(n) char *n; /* directory to open */ X/* Start searching for files in the VMS directory n */ X{ X char *c; /* scans VMS path */ X dstrm *d; /* malloc'd return value */ X int m; /* length of name */ X char *p; /* malloc'd temporary string */ X X if ((d = (dstrm *)malloc(sizeof(dstrm))) == NULL || X (p = malloc((m = strlen(n)) + 4)) == NULL) X return NULL; X /* Directory may be in form "[DIR.SUB1.SUB2]" or "[DIR.SUB1]SUB2.DIR;1". X If latter, convert to former. */ X if (m > 0 && *(c = strcpy(p,n)+m-1) != ']') X { X while (--c > p && *c != ';') X ; X if (c-p < 5 || strncmp(c-4, ".DIR", 4)) X { X free((voidp *)d); free((voidp *)p); X return NULL; X } X c -= 3; X *c-- = '\0'; /* terminate at "DIR;#" */ X *c = ']'; /* "." --> "]" */ X while (c > p && *--c != ']') X ; X *c = '.'; /* "]" --> "." */ X } X strcat(p, "*.*"); X vms_wild(p, d); /* set up wildcard */ X free((voidp *)p); X return d; X} X struct direct *readdir(d) dstrm *d; /* directory stream to read from */ X/* Return pointer to first or next directory entry, or NULL if end. */ X{ X int r; /* return code */ X X do { X d->fab.fab$w_ifi = 0; /* internal file index: what does this do? */ X X /* get next match to possible wildcard */ X if ((r = sys$search(&d->fab)) == RMS$_NORMAL) X { X d->d_name[d->nam.nam$b_rsl] = '\0'; /* null terminate */ X return (struct direct *)d; /* OK */ X } X } while (r == RMS$_PRV); X return NULL; X} X# define closedir free X#endif /* VMS */ X X X#ifdef NODIR /* for AT&T 3B1 */ X/* X** Apparently originally by Rich Salz. X** Cleaned up and modified by James W. Birdsall. X*/ X X# define opendir(path) fopen(path, "r") X struct direct *readdir(dirp) DIR *dirp; X{ X static struct direct entry; X X if (dirp == NULL) X return NULL; X for (;;) X if (fread (&entry, sizeof (struct direct), 1, dirp) == 0) X return NULL; X else if (entry.d_ino) X return (&entry); X} /* end of readdir() */ X X# define closedir(dirp) fclose(dirp) X#endif /* NODIR */ X X X#ifdef DIRENT local dstrm *opend(n) char *n; /* directory name to open */ X/* Open the directory *n, returning a pointer to an allocated dstrm, or X NULL if error. */ X{ X dstrm *d; /* pointer to malloc'ed directory stream */ X X if ((d = (dstrm *)malloc(sizeof(dstrm))) == NULL) X return NULL; X if ((d->f = open(n, 0, 0)) < 0) /* open directory */ X return NULL; X d->p = d->q = d->b; /* buffer is empty */ X return d; X} X#else /* !DIRENT */ X# define opend opendir /* just use opendir() */ X#endif /* ?DIRENT */ X X local char *readd(d) dstrm *d; /* directory stream to read from */ X/* Return a pointer to the next name in the directory stream d, or NULL if X no more entries or an error occurs. */ X{ X struct direct *e; /* directory entry read */ X X#ifdef DIRENT X int n; /* number of entries read by getdents */ X X if (d->p >= d->q) /* if empty, fill buffer */ X if ((n = getdents(d->f, d->b, DBSZ)) <= 0) X return NULL; X else X d->q = n + (d->p = d->b); X e = (struct direct *)(d->p); /* point to entry */ X d->p += ((struct direct *)(d->p))->d_reclen; /* advance */ X return e->d_name; /* return name */ X#else /* !DIRENT */ X return (e = readdir(d)) == NULL ? (char *)NULL : e->d_name; X#endif /* ?DIRENT */ X} X X X#ifdef DIRENT local void closed(d) dstrm *d; /* directory stream to close */ X/* Close the directory stream */ X{ X close(d->f); X free((voidp *)d); X} X#else /* !DIRENT */ X# define closed closedir X#endif /* ?DIRENT */ X X X#ifdef MSDOS int wild(p) char *p; /* path/pattern to match */ X/* If not in exclude mode, expand the pattern based on the contents of the X file system. Return an error code in the ZE_ class. */ X{ X dstrm *d; /* stream for reading directory */ X char *e; /* name found in directory */ X int f; /* true if there was a match */ X char *n; /* constructed name from directory */ X char *q; /* temporary variable */ X int r; /* temporary variable */ X char v[4]; /* space for device current directory */ X X /* If excluding, don't bother with file system */ X if (exflag) X return procname(p); X X /* Normalize pattern to upper case, path delimiter as '/'. */ X#ifndef OS2 X strupr(p); /* convert to upper case */ X#endif /* !OS2 */ X for (q = p; *q; q++) /* use / consistently */ X if (*q == '\\') X *q = '/'; X X /* Only name can have special matching characters */ X if ((q = isshexp(p)) != NULL && X (strrchr(q, '/') != NULL || strrchr(q, ':') != NULL)) X return ZE_PARMS; X X /* Separate path and name */ X if ((q = strrchr(p, '/')) != NULL) X *q++ = 0; X else if (*p && *(p+1) == ':') X { X q = p + 2; X v[0] = *p; X strcpy(v+1, ":."); X p = v; X } X else X { X q = p; X p = "."; X } X if (*p == 0) X p = "/"; X X /* Search that level for matching names */ X if ((d = opend(p)) == NULL) X return ZE_MISS; X if (strcmp(p+1, ":.") == 0) X *(p+2) = 0; X f = 0; X while ((e = readd(d)) != NULL) X if (strcmp(e, ".") && strcmp(e, "..") && MATCH(q, e)) X { X f = 1; X if (strcmp(p, ".") == 0) X procname(e); X else if (*p && strcmp(p+1, ":") == 0) X { X if ((n = malloc(strlen(e) + 3)) == NULL) X return ZE_MEM; X r = procname(strcat(strcpy(n, p), e)); X free((voidp *)n); X if (r) X return r; X } X else X { X if ((n = malloc(strlen(p) + strlen(e) + 2)) == NULL) X return ZE_MEM; X if (strcmp(p, "/")) X strcpy(n, p); X else X *n = 0; X r = procname(strcat(strcat(n, "/"), e)); X free((voidp *)n); X if (r) X return r; X } X } X closed(d); X X /* Done */ X return f ? ZE_OK : ZE_MISS; X} X#endif /* MSDOS */ X X X#ifdef VMS int wild(p) char *p; /* path/pattern to match */ X/* Expand the pattern based on the contents of the file system. Return an X error code in the ZE_ class. */ X{ X dstrm *d; /* stream for reading directory */ X char *e; /* name found in directory */ X int f; /* true if there was a match */ X X /* Search given pattern for matching names */ X if ((d = (dstrm *)malloc(sizeof(dstrm))) == NULL) X return ZE_MEM; X vms_wild(p, d); /* pattern may be more than just directory name */ X f = 0; X while ((e = readd(d)) != NULL) /* "dosmatch" is already built in */ X if (procname(e) == ZE_OK) X f = 1; X closed(d); X X /* Done */ X return f ? ZE_OK : ZE_MISS; X} X#endif /* VMS */ X X char *getnam(n) char *n; /* where to put name (must have >=FNMAX+1 bytes) */ X/* Read a space, \n, \r, or \t delimited name from stdin into n, and return X n. If EOF, then return NULL. Also, if the name read is too big, return X NULL. */ X{ X int c; /* last character read */ X char *p; /* pointer into name area */ X X p = n; X while ((c = getchar()) == ' ' || c == '\n' || c == '\r' || c == '\t') X ; X if (c == EOF) X return NULL; X do { X if (p - n >= FNMAX) X return NULL; X *p++ = (char)c; X c = getchar(); X } while (c != EOF && c != ' ' && c != '\n' && c != '\r' && c != '\t'); X *p = 0; X return n; X} X X struct flist far *fexpel(f) struct flist far *f; /* entry to delete */ X/* Delete the entry *f in the doubly-linked found list. Return pointer to X next entry to allow stepping through list. */ X{ X struct flist far *t; /* temporary variable */ X X t = f->nxt; X *(f->lst) = t; /* point last to next, */ X if (t != NULL) X t->lst = f->lst; /* and next to last */ X if (f->name != NULL) /* free memory used */ X free((voidp *)(f->name)); X if (f->zname != NULL) X free((voidp *)(f->zname)); X farfree((voidp far *)f); X fcount--; /* decrement count */ X return t; /* return pointer to next */ X} X X local int fqcmp(a, b) voidp *a, *b; /* pointers to pointers to found entries */ X/* Used by qsort() to compare entries in the found list by name. */ X{ X return strcmp((*(struct flist far **)a)->name, X (*(struct flist far **)b)->name); X} X X local int fqcmpz(a, b) voidp *a, *b; /* pointers to pointers to found entries */ X/* Used by qsort() to compare entries in the found list by zname. */ X{ X return strcmp((*(struct flist far **)a)->zname, X (*(struct flist far **)b)->zname); X} X X local char *last(p) char *p; /* sequence of / delimited path components */ X/* Return a pointer to the start of the last path component. */ X{ X char *t; /* temporary variable */ X X#ifdef VMS X if ((t = strrchr(p, ']')) != NULL) X#else /* !VMS */ X if ((t = strrchr(p, '/')) != NULL) X#endif /* ?VMS */ X return t + 1; X else X return p; X} X X X#define TOUP(c) ((c) >= 'a' && (c) <= 'z' ? (c)-'a'+'A' : (c)) X local char *msname(n) char *n; X/* Reduce all path components to MSDOS upper case 8.3 style names. Probably X should also check for invalid characters, but I don't know which ones X those are. */ X{ X int c; /* current character */ X int f; /* characters in current component */ X char *p; /* source pointer */ X char *q; /* destination pointer */ X X p = q = n; X f = 0; X while ((c = *p++) != 0) X if (c == '/') X { X *q++ = (char)c; X f = 0; /* new component */ X } X else if (c == '.') X if (f < 9) X { X *q++ = (char)c; X f = 9; /* now in file type */ X } X else X f = 12; /* now just excess characters */ X else X if (f < 12 && f != 8) X { X *q++ = (char)(TOUP(c)); X f++; /* do until end of name or type */ X } X *q = 0; X return n; X} X X X#ifdef VMS local char *strlower(s) char *s; /* string to convert */ X/* Convert all uppercase letters to lowercase in string s */ X{ X char *p; /* scans string */ X X for (p = s; *p; p++) X if (*p >= 'A' && *p <= 'Z') X *p += 'a' - 'A'; X return s; X} X local char *strupper(s) char *s; /* string to convert */ X/* Convert all lowercase letters to uppercase in string s */ X{ X char *p; /* scans string */ X X for (p = s; *p; p++) X if (*p >= 'a' && *p <= 'a') X *p -= 'a' - 'A'; X return s; X} X#endif /* VMS */ X X local char *ex2in(x) char *x; /* external file name */ X/* Convert the external file name to a zip file name, returning the malloc'ed X string or NULL if not enough memory. */ X{ X char *n; /* internal file name (malloc'ed) */ X char *t; /* shortened name */ X X /* Find starting point in name before doing malloc */ X#ifdef MSDOS /* msdos */ X t = *x && *(x + 1) == ':' ? x + 2 : x; X while (*t == '/' || *t == '\\') X t++; X#else /* !MSDOS */ X# ifdef VMS /* vms */ X t = x; X if ((n = strrchr(t, ':')) != NULL) X t = n + 1; X if (*t == '[' && (n = strrchr(t, ']')) != NULL) X if ((x = strchr(t, '.')) != NULL && x < n) X t = x + 1; X else X t = n + 1; X# else /* !VMS */ /* unix */ X for (t = x; *t == '/'; t++) X ; X# endif /* ?VMS */ X#endif /* ?MSDOS */ X if (!pathput) X t = last(t); X X /* Malloc space for internal name and copy it */ X if ((n = malloc(strlen(t) + 1)) == NULL) X return NULL; X strcpy(n, t); X X /* Make changes, if any, to the copied name (leave original intact) */ X#ifdef MSDOS X for (t = n; *t; t++) X if (*t == '\\') X *t = '/'; X#endif /* MSDOS */ X#ifdef VMS X if ((t = strrchr(n, ']')) != NULL) X { X *t = '/'; X while (--t > n) X if (*t == '.') X *t = '/'; X } X X /* Fix from Greg Roelofs: */ X /* Get current working directory and strip from n (t now = n) */ X { X char cwd[256], *p, *q; X int c; X X if (getcwd(cwd, 256) && ((p = strchr(cwd, '.')) != NULL)) X { X ++p; X if ((q = strrchr(p, ']')) != NULL) X { X *q = '/'; X while (--q > p) X if (*q == '.') X *q = '/'; X /* strip bogus path parts from n */ X if (strncmp(n, p, (c=strlen(p))) == 0) X { X q = n + c; X while (*t++ = *q++) X ; X } X } X } X } X strlower(n); X if (!vmsver) X if ((t = strrchr(n, ';')) != NULL) X *t = 0; X#endif /* VMS */ X if (dosify) X msname(n); X X /* Returned malloc'ed name */ X return n; X} X X char *in2ex(n) char *n; /* internal file name */ X/* Convert the zip file name to an external file name, returning the malloc'ed X string or NULL if not enough memory. */ X{ X char *x; /* external file name */ X#ifdef VMS X char *t; /* scans name */ X X if ((t = strrchr(n, '/')) == NULL) X#endif /* VMS */ X { X if ((x = malloc(strlen(n) + 1 + PAD)) == NULL) X return NULL; X strcpy(x, n); X } X#ifdef VMS X else X { X if ((x = malloc(strlen(n) + 3 + PAD)) == NULL) X return NULL; X strcpy(x, "[."); X strcpy(x + 2, n); X *(t = x + 2 + (t - n)) = ']'; X while (--t > x) X if (*t == '/') X *t = '.'; X } X strupper(x); X#endif /* VMS */ X return x; X} X X int exclude() X/* Change from including to excluding names when procname() called. Return X an error code in the ZE_ class. */ X{ X struct flist far *f; /* steps through found linked list */ X int j; /* index for s */ X struct flist far **s; /* sorted table */ X X /* sort found list, remove duplicates */ X if (fcount) X { X if ((s = (struct flist far **)malloc( X fcount * sizeof(struct flist far *))) == NULL) X return ZE_MEM; X for (j = 0, f = found; f != NULL; f = f->nxt) X s[j++] = f; X qsort((char *)s, fcount, sizeof(struct flist far *), fqcmp); X for (j = fcount - 1; j > 0; j--) X if (strcmp(s[j - 1]->name, s[j]->name) == 0) X fexpel(s[j]); /* fexpel() changes fcount */ X qsort((char *)s, fcount, sizeof(struct flist far *), fqcmpz); X for (j = 1; j < fcount; j++) X if (strcmp(s[j - 1]->zname, s[j]->zname) == 0) X { X warn("name in zip file repeated: ", s[j]->zname); X warn(" first full name: ", s[j - 1]->name); X warn(" second full name: ", s[j]->name); X return ZE_PARMS; X } X free((voidp *)s); X } X exflag = 1; X return ZE_OK; X} X X local int newname(n) char *n; /* name to add (or exclude) */ X/* Add (or exclude) a name that is not in the zip file. Return an error X code in the ZE_ class. */ X{ X char *m; X struct flist far *f; /* where in found, or new found entry */ X struct zlist far *z; /* where in zfiles (if found) */ X X /* Search for name in zip file. If there, mark it, else add to X list of new names to do (or remove from that list). */ X if ((m = ex2in(n)) == NULL) X return ZE_MEM; X if ((z = zsearch(m)) != NULL) X if (exflag) X { X z->mark = 0; X free((voidp *)m); X if (verbose) X printf("zip diagnostic: excluding %s\n", z->name); X } X else X { X free((voidp *)(z->name)); X free((voidp *)(z->zname)); X if ((z->name = malloc(strlen(n) + 1 + PAD)) == NULL) X return ZE_MEM; X strcpy(z->name, n); X z->zname = m; X z->mark = 1; X if (verbose) X printf("zip diagnostic: including %s\n", z->name); X } X else X if (exflag) X { X /* search list for name--if there, remove it */ X for (f = found; f != NULL; f = f->nxt) X if (strcmp(n, f->name) == 0) X { X fexpel(f); X break; X } X free((voidp *)m); X } X else X { X /* allocate space and add to list */ X if ((f = (struct flist far *)farmalloc(sizeof(struct flist))) == NULL || X (f->name = malloc(strlen(n) + 1 + PAD)) == NULL) X { X if (f != NULL) X farfree((voidp far *)f); X return ZE_MEM; X } X strcpy(f->name, n); X f->zname = m; X *fnxt = f; X f->lst = fnxt; X f->nxt = NULL; X fnxt = &f->nxt; X fcount++; X } X return ZE_OK; X} X X int procname(n) char *n; /* name to process */ X/* Process a name or sh expression to operate on (or exclude). Return X an error code in the ZE_ class. */ X{ X char *a; /* path and name for recursion */ X dstrm *d; /* directory stream from opend() */ X char *e; /* pointer to name from readd() */ X struct flist far *f; /* steps through found list */ X int m; /* matched flag */ X char *p; /* path for recursion */ X struct stat s; /* result of stat() */ X struct zlist far *z; /* steps through zfiles list */ X X if ( X#ifdef S_IFLNK /* if symbolic links exist ... */ X linkput ? lstat(n, &s) : X#endif /* S_IFLNK */ X stat(n, &s) X#ifdef __TURBOC__ /* Borland bug: stat() succeeds on wild card names! */ X || isshexp(n) X#endif /* __TURBOC__ */ X ) X { X /* Not a file--search for shell expression in zip file */ X p = ex2in(n); /* shouldn't affect matching chars */ X m = 1; X for (z = zfiles; z != NULL; z = z->nxt) X if (MATCH(p, z->zname)) X { X z->mark = !exflag; X if (verbose) X printf("zip diagnostic: %scluding %s\n", X exflag ? "ex" : "in", z->name); X m = 0; X } X /* If excluding, also search for expression in found list */ X if (exflag) X { X for (f = found; f != NULL;) X if (MATCH(p, f->zname)) X { X f = fexpel(f); X m = 0; X } X else X f = f->nxt; X } X free((voidp *)p); X if (m) X return ZE_MISS; /* no match */ X } X else X { X /* Live name--use if file, recurse if directory */ X#ifdef MSDOS X#ifndef OS2 X strupr(n); /* convert to upper case */ X#endif /* !OS2 */ X for (p = n; *p; p++) /* use / consistently */ X if (*p == '\\') X *p = '/'; X#endif /* MSDOS */ X switch (s.st_mode & S_IFMT) X { X case S_IFREG: /* add or remove name of file */ X#ifdef S_IFLNK X case S_IFLNK: X#endif /* S_IFLNK */ X if ((m = newname(n)) != ZE_OK) X return m; X break; X case S_IFDIR: /* recurse into directory */ X if (recurse && (d = opend(n)) != NULL) X { X#ifdef VMS X while ((e = readd(d)) != NULL) X if ((m = procname(e)) != ZE_OK) /* recurse on name */ X { X /* want to just set warning error and continue */ X closed(d); X return m; X } X#else /* !VMS */ X if ((p = malloc(strlen(n)+2)) == NULL) X return ZE_MEM; X if (strcmp(n, ".") == 0) X *p = 0; /* avoid "./" prefix */ X else X { X strcpy(p, n); X a = p + strlen(p); X if (a[-1] != '/') X strcpy(a, "/"); X } X while ((e = readd(d)) != NULL) X if (strcmp(e, ".") && strcmp(e, "..")) X { X if ((a = malloc(strlen(p) + strlen(e) + 1)) == NULL) X { X free((voidp *)p); X closed(d); X return ZE_MEM; X } X strcat(strcpy(a, p), e); X if ((m = procname(a)) != ZE_OK) /* recurse on name */ X { X free((voidp *)a); free((voidp *)p); X closed(d); X return m; X } X free((voidp *)a); X } X free((voidp *)p); X#endif /* ?VMS */ X closed(d); X } X } X } X return ZE_OK; X} X X X#ifndef __TURBOC__ local int cmptime(p, q) struct tm *p, *q; /* times to compare */ X/* Return negative if time p is before time q, positive if after, and X zero if the same */ X{ X int r; /* temporary variable */ X X if ((r = p->tm_year - q->tm_year) != 0) X return r; X else if ((r = p->tm_mon - q->tm_mon) != 0) X return r; X else if ((r = p->tm_mday - q->tm_mday) != 0) X return r; X else if ((r = p->tm_hour - q->tm_hour) != 0) X return r; X else if ((r = p->tm_min - q->tm_min) != 0) X return r; X else X return p->tm_sec - q->tm_sec; X} X X local time_t invlocal(t) struct tm *t; /* time to convert */ X/* Find inverse of localtime() using bisection. This routine assumes that X time_t is an integer type, either signed or unsigned. The expectation X is that sometime before the year 2038, time_t will be made a 64-bit X integer, and this routine will still work. */ X{ X time_t i; /* midpoint of current root range */ X time_t l; /* lower end of root range */ X time_t u; /* upper end of root range */ X X /* Bracket the root [0,largest time_t]. Note: if time_t is a 32-bit signed X integer, then the upper bound is GMT 1/19/2038 03:14:07, after which all X the Unix systems in the world come to a grinding halt. Either that, or X all those systems will suddenly find themselves transported to December X of 1901 ... */ X l = 0; X u = 1; X while (u < (u << 1)) X u = (u << 1) + 1; X X /* Find the root */ X while (u - l > 1) X { X i = l + ((u - l) >> 1); X if (cmptime(localtime(&i), t) <= 0) X l = i; X else X u = i; X } X return l; X} X#endif /* !__TURBOC__ */ X X void stamp(f, d) char *f; /* name of file to change */ ulg d; /* dos-style time to change it to */ X/* Set last updated and accessed time of file f to the DOS time d. */ X{ X#ifdef __TURBOC__ X int h; /* file handle */ X X if ((h = open(f, 0)) != -1) X { X setftime(h, (struct ftime *)&d); X close(h); X } X#else /* !__TURBOC__ */ X#ifdef VMS X warn("timestamp not implemented yet under VMS", ""); X#else /* !VMS */ X struct tm t; /* argument for invlocal() */ X time_t u[2]; /* argument for utime() */ X X /* Convert DOS time to time_t format in u[0] and u[1] */ X t.tm_sec = (int)(d << 1) & 0x3e; X t.tm_min = (int)(d >> 5) & 0x3f; X t.tm_hour = (int)(d >> 11) & 0x1f; X t.tm_mday = (int)(d >> 16) & 0x1f; X t.tm_mon = ((int)(d >> 21) & 0xf) - 1; X t.tm_year = ((int)(d >> 25) & 0x7f) + 80; X u[0] = u[1] = invlocal(&t); X X /* Set updated and accessed times of f */ X utime(f, u); X#endif /* ?VMS */ X#endif /* ?__TURBOC__ */ X} X X local void inctime(s) struct tm *s; /* time to increment in place */ X/* Increment the time structure *s by one second, return the result in X place. */ X{ X int y; /* temporary variable */ X X /* days in each month, except for February */ X static int days[] = {31,0,31,30,31,30,31,31,30,31,30,31}; X X /* Set days in February from year (1900 is a leap year, 2000 is not) */ X y = s->tm_year + 1900; X days[1] = y % 4 == 0 && (y % 100 != 0 || y % 400 == 0) ? 29 : 28; X X /* Increment time with carry */ X if (s->tm_sec != 59) X s->tm_sec++; X else if (s->tm_sec = 0, s->tm_min != 59) X s->tm_min++; X else if (s->tm_min = 0, s->tm_hour != 23) X s->tm_hour++; X else if (s->tm_hour = 0, s->tm_mday != days[s->tm_mon]) X s->tm_mday++; X else if (s->tm_mday = 1, s->tm_mon != 11) X s->tm_mon++; X else X { X s->tm_mon = 0; X s->tm_year++; X } X} X X ulg dostime(y, n, d, h, m, s) int y; /* year */ int n; /* month */ int d; /* day */ int h; /* hour */ int m; /* minute */ int s; /* second */ X/* Convert the date y/n/d and time h:m:s to a four byte DOS date and X time (date in high two bytes, time in low two bytes allowing magnitude X comparison). */ X{ X return y < 1980 ? dostime(1980, 1, 1, 0, 0, 0) : X (((ulg)y - 1980) << 25) | ((ulg)n << 21) | ((ulg)d << 16) | X ((ulg)h << 11) | ((ulg)m << 5) | ((ulg)s >> 1); X} X X local ulg unix2dostime(t) time_t *t; /* unix time to convert */ X/* Return the Unix time t in DOS format, rounded up to the next two X second boundary. */ X{ X struct tm *s; /* result of localtime() */ X X s = localtime(t); /* Use local time since MSDOS does */ X inctime(s); /* Add one second to round up */ X return dostime(s->tm_year + 1900, s->tm_mon + 1, s->tm_mday, X s->tm_hour, s->tm_min, s->tm_sec); X} X X ulg filetime(f, a, n) char *f; /* name of file to get info on */ ulg *a; /* return value: file attributes */ long *n; /* return value: file size */ X/* If file *f does not exist, return 0. Else, return the file's last X modified date and time as an MSDOS date and time. The date and X time is returned in a long with the date most significant to allow X unsigned integer comparison of absolute times. Also, if a is not X a NULL pointer, store the file attributes there, with the high two X bytes being the Unix attributes, and the low byte being a mapping X of that to DOS attributes. If n is not NULL, store the file size X there. */ X{ X struct stat s; /* results of stat() */ X X#ifdef S_IFLNK X if (linkput ? lstat(f, &s) == 0 && ((s.st_mode & S_IFMT) == S_IFREG || X (s.st_mode & S_IFMT) == S_IFLNK) : X#else /* !S_IFLNK */ X if ( X#endif /* ?S_IFLNK */ X stat(f, &s) == 0 && (s.st_mode & S_IFMT) == S_IFREG) X { X if (a != NULL) X *a = (s.st_mode << 16) | !(s.st_mode & S_IWRITE); X if (n != NULL) X *n = s.st_size; X#ifdef VMS X return unix2dostime(&s.st_ctime); /* Use creation time in VMS */ X#else /* !VMS */ X return unix2dostime(&s.st_mtime); X#endif /* ?VMS */ X } X else X return 0; X} X X int issymlnk(a) ulg a; /* Attributes returned by filetime() */ X/* Return true if the attributes are those of a symbolic link */ X{ X#ifdef S_IFLNK X return ((a >> 16) & S_IFMT) == S_IFLNK; X#else /* !S_IFLNK */ X return (int)a & 0; /* avoid warning on unused parameter */ X#endif /* ?S_IFLNK */ X} X X int deletedir(d) char *d; /* directory to delete */ X/* Delete the (empty) directory *d. Return the result of rmdir(), delete(), X or system(). */ X{ X#ifdef RMDIR X /* code from Greg Roelofs, who horked it from Mark Edwards (unzip) */ X int r, len; X char *s; /* malloc'd string for system command */ X X len = strlen(d); X if ((s = malloc(len + 34)) == NULL) X return 127; X X#ifdef VMS X { X char *c; /* pointer into VMS path */ X /* convert "DEV:[DIR.SUB1.SUB2]" form to "DEV:[DIR.SUB1]SUB2.DIR;0" */ X strcat(strcpy(s, "set prot=(o:rwed) "), d); /* d starts at s+18 */ X if (*(c = s+17+len) != ']') X { X free(s); X return 127; X } X strcpy(c, ".DIR;0"); /* 0 translates to highest version */ X while (--c > s+18 && *c != '.' && *c != '[') ; X if (c == s+18) X { X free(s); X return 127; X } X if (*c == '.') X *c = ']'; X else if (*--c == ']') /* presumably of form "DEV:[DIR.SUB1.][SUB2]" */ X { /* (possible to have "DEV:[DIR.SUB1.][][SUB2]"?) */ X char *b = c + 2; X c[-1] = ']'; X while (*c++ = *b++) ; X } X else /* must have reached device name: can't delete top level */ X { X free(s); X return 127; X } X } X /* unprotect directory and delete it as a file. May fail if exists X normal file "foo.dir" on top of directory "foo.dir" */ X system(s); X r = delete(s+18); X#else /* !VMS */ X sprintf(s, "IFS=\" \t\n\" /bin/rmdir %s 2>/dev/null", d); X r = system(s); X#endif /* ?VMS */ X free(s); X return r; X#else /* !RMDIR */ X return rmdir(d); X#endif /* ?RMDIR */ X} X X X#endif /* !UTIL */ X X int destroy(f) char *f; /* file to delete */ X/* Delete the file *f, returning non-zero on failure. */ X{ X return unlink(f); X} X X int replace(d, s) char *d, *s; /* destination and source file names */ X/* Replace file *d by file *s, removing the old *s. Return an error code X in the ZE_ class. */ X{ X struct stat t; /* results of stat() */ X X if (stat(d, &t) == 0 && unlink(d)) X return ZE_CREAT; /* Can't erase zip file--give up */ X if (link(s, d)) /* Just move s on top of d */ X#ifndef VMS /* For VMS, assume failure is EXDEV */ X if (errno != EXDEV) X return ZE_CREAT; X else X#endif /* !VMS */ X { X FILE *f, *g; /* source and destination files */ X int r; /* temporary variable */ X X if ((f = fopen(s, FOPR)) == NULL) X return ZE_TEMP; X if ((g = fopen(d, FOPW)) == NULL) X { X fclose(f); X return ZE_CREAT; X } X r = fcopy(f, g, (ulg)-1L); X fclose(f); X if (fclose(g) || r != ZE_OK) X { X unlink(d); X return r ? (r == ZE_TEMP ? ZE_WRITE : r) : ZE_WRITE; X } X#ifdef VMS /* only delete if rename failed: previous version may exist */ X unlink(s); X } X#else /* !VMS */ X } X unlink(s); X#endif /* !VMS */ X return ZE_OK; X} X X int getfileattr(f) char *f; /* file path */ X/* Return the file attributes for file f or -1 if failure */ X{ X struct stat s; X X return stat(f, &s) == 0 ? s.st_mode : 0; X} X X int setfileattr(f, a) char *f; /* file path */ int a; /* attributes returned by getfileattr() */ X/* Give the file f the attributes a, return non-zero on failure */ X{ X#ifdef VMS X return 0; X#else /* !VMS */ X return chmod(f, a); X#endif /* ?VMS */ X} X X char *tempname(c) int c; /* character to insert in name */ X/* Return a temporary file name in its own malloc'ed space, using tempath. */ X{ X char *p; /* temporary pointer */ X char *t; /* malloc'ed space for name */ X X if (tempath != NULL) X { X if ((t = malloc(strlen(tempath)+10)) == NULL) X return NULL; X strcpy(t, tempath); X if (t[strlen(t)-1] != '/') X strcat(t, "/"); X } X else X { X if ((t = malloc(9)) == NULL) X return NULL; X *t = 0; X } X p = t + strlen(t); X *p++ = '_'; X *p++ = (char)c; X strcpy(p, "XXXXXX"); X return mktemp(t); X} X X int fcopy(f, g, n) XFILE *f, *g; /* source and destination files */ ulg n; /* number of bytes to copy or -1 for all */ X/* Copy n bytes from file *f to file *g, or until EOF if n == -1. Return X an error code in the ZE_ class. */ X{ X char *b; /* malloc'ed buffer for copying */ X extent k; /* result of fread() */ X ulg m; /* bytes copied so far */ X X if ((b = malloc(BSZ)) == NULL) X return ZE_MEM; X m = 0; X while (n == -1L || m < n) X { X if ((k = fread(b, 1, n == -1 ? X BSZ : (n - m < BSZ ? (extent)(n - m) : BSZ), f)) == 0) X if (ferror(f)) X { X free((voidp *)b); X return ZE_READ; X } X else X break; X if (fwrite(b, 1, k, g) != k) X { X free((voidp *)b); X return ZE_TEMP; X } X m += k; X } X free((voidp *)b); X return ZE_OK; X} X X X#ifndef EXPORT X X#ifndef MSVMS X local int echofd = -1; /* file descriptor whose echo is off */ X void echoff(f) int f; /* file descriptor to turn echo off on */ X/* Turn echo off for file descriptor f. Assumes that f is a tty device. */ X{ X struct sgttyb sg; /* tty device structure */ X X echofd = f; X GTTY(f, &sg); /* get settings */ X sg.sg_flags &= ~ECHO; /* turn echo off */ X STTY(f, &sg); X} X void echon() X/* Turn echo back on for file descriptor echofd. */ X{ X struct sgttyb sg; /* tty device structure */ X X if (echofd != -1) X { X GTTY(echofd, &sg); /* get settings */ X sg.sg_flags |= ECHO; /* turn echo on */ X STTY(echofd, &sg); X echofd = -1; X } X} X X#endif /* !MSVMS */ X X char *getp(m, p, n) char *m; /* prompt for password */ char *p; /* return value: line input */ int n; /* bytes available in p[] */ X/* Get a password of length n-1 or less into *p using the prompt *m. X The entered password is not echoed. Return p on success, NULL on X failure (can't get controlling tty). */ X{ X char c; /* one-byte buffer for read() to use */ X int i; /* number of characters input */ X char *w; /* warning on retry */ X X#ifndef MSVMS X int f; /* file decsriptor for tty device */ X X /* Turn off echo on tty */ X if (!isatty(2)) X return NULL; /* error if not tty */ X if ((f = open(ttyname(2), 0, 0)) == -1) X return NULL; X echoff(f); /* turn echo off */ X#endif /* !MSVMS */ X X /* Get password */ X w = ""; X do { X fputs(w, stderr); /* warning if back again */ X fputs(m, stderr); /* prompt */ X fflush(stderr); X i = 0; X do { /* read line, keeping n */ X#ifdef MSVMS X if ((c = (char)getch()) == '\r') X c = '\n'; X#else /* !MSVMS */ X read(f, &c, 1); X#endif /* ?MSVMS */ X if (i < n) X p[i++] = c; X } while (c != '\n'); X putc('\n', stderr); fflush(stderr); X w = "(line too long--try again)\n"; X } while (p[i-1] != '\n'); X p[i-1] = 0; /* terminate at newline */ X X#ifndef MSVMS X /* Turn echo back on */ X echon(); /* turn echo back on */ X close(f); X#endif /* !MSVMS */ X X /* Return pointer to password */ X return p; X} X X#endif /* !EXPORT */ X X X#ifdef ZMEM X X/************************/ X/* Function memset() */ X/************************/ X X/* X * memset - for systems without it X * bill davidsen - March 1990 X */ X char * memset(buf, init, len) register char *buf; /* buffer loc */ register int init; /* initializer */ register unsigned int len; /* length of the buffer */ X{ X char *start; X X start = buf; X while (len--) *(buf++) = init; X return(start); X} X X X/************************/ X/* Function memcpy() */ X/************************/ X char * memcpy(dst,src,len) /* v2.0f */ register char *dst, *src; register unsigned int len; X{ X char *start; X X start = dst; X while (len--) X *dst++ = *src++; X return(start); X} X X X/************************/ X/* Function memcmp() */ X/************************/ X int memcmp(b1,b2,len) /* jpd@usl.edu -- 11/16/90 */ register char *b1, *b2; register unsigned int len; X{ X X if (len) do { /* examine each byte (if any) */ X if (*b1++ != *b2++) X return (*--((uch *)b1) - *--((uch *)b2)); /* exit when miscompare */ X } while (--len); X X return(0); /* no miscompares, yield 0 result */ X} X X#endif /* ZMEM */ END_OF_FILE if test 44358 -ne `wc -c <'fileio.c'`; then echo shar: \"'fileio.c'\" unpacked with wrong size! fi # end of 'fileio.c' fi echo shar: End of archive 6 $of 7$. cp /dev/null ark6isdone MISSING="" for I in 1 2 3 4 5 6 7 ; do if test ! -f ark${I}isdone ; then MISSING="${MISSING} ${I}" fi done if test "${MISSING}" = "" ; then echo You have unpacked all 7 archives. rm -f ark[1-9]isdone else echo You still need to unpack the following archives: echo " " ${MISSING} fi ## End of shell archive. exit 0